/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow7Stride4Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Forward>;
TYPED_TEST_SUITE(AvgWindow7Stride4Forward, GTestTypePairs);
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 28., 31., 58., 61.,
                                         64., 91., 94., 97.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 41., 81., 85.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49.,  50.,  55.,  56.,  61.,  62.,
                                         115., 116., 121., 122., 127., 128.,
                                         181., 182., 187., 188., 193., 194.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  81.,  82.,
                                         161., 162., 169., 170.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  99.,  100., 109., 110., 111., 112., 121., 122., 123., 124.,
      229., 230., 231., 232., 241., 242., 243., 244., 253., 254., 255., 256.,
      361., 362., 363., 364., 373., 374., 375., 376., 385., 386., 387., 388.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 147., 148., 161., 162.,
                                         163., 164., 321., 322., 323., 324.,
                                         337., 338., 339., 340.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27.5, 31.,  34.,  63.5, 67.,
                                         70.,  99.5, 103., 106.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40., 44., 88., 92.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54.,  55.,  61.,  62.,  67.,  68.,
                                         126., 127., 133., 134., 139., 140.,
                                         198., 199., 205., 206., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  80.,  87.,  88.,
                                         175., 176., 183., 184.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107., 108., 109., 110., 121., 122., 123., 124., 133., 134., 135., 136.,
      251., 252., 253., 254., 265., 266., 267., 268., 277., 278., 279., 280.,
      395., 396., 397., 398., 409., 410., 411., 412., 421., 422., 423., 424.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 159., 160., 173., 174.,
                                         175., 176., 349., 350., 351., 352.,
                                         365., 366., 367., 368.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31., 34.,  38.,  40.5, 73.,  76.,
                                         80., 82.5, 115., 118., 122., 124.5};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46., 50., 102., 106.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  67.,  68.,  75.,  76.,  80.,  81.,  145., 146., 151., 152.,
      159., 160., 164., 165., 229., 230., 235., 236., 243., 244., 248., 249.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  92.,  99.,  100.,
                                         203., 204., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 133., 134., 135., 136., 149., 150., 151., 152.,
      159., 160., 161., 162., 289., 290., 291., 292., 301., 302., 303., 304.,
      317., 318., 319., 320., 327., 328., 329., 330., 457., 458., 459., 460.,
      469., 470., 471., 472., 485., 486., 487., 488., 495., 496., 497., 498.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 183., 184., 197., 198.,
                                         199., 200., 405., 406., 407., 408.,
                                         421., 422., 423., 424.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.5, 33.5, 36.5, 69., 72.,
                                         75.,  102., 105., 108.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 41., 81., 85.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60.,  61.,  66.,  67.,  72.,  73.,
                                         137., 138., 143., 144., 149., 150.,
                                         203., 204., 209., 210., 215., 216.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  81.,  82.,
                                         161., 162., 169., 170.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119., 120., 121., 122., 131., 132., 133., 134., 143., 144., 145., 146.,
      273., 274., 275., 276., 285., 286., 287., 288., 297., 298., 299., 300.,
      405., 406., 407., 408., 417., 418., 419., 420., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 147., 148., 161., 162.,
                                         163., 164., 321., 322., 323., 324.,
                                         337., 338., 339., 340.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33.5, 37.,   40.,  75.5, 79.,
                                         82.,  111.5, 115., 118.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40., 44., 88., 92.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {66.,  67.,  73.,  74.,  79.,  80.,
                                         150., 151., 157., 158., 163., 164.,
                                         222., 223., 229., 230., 235., 236.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  80.,  87.,  88.,
                                         175., 176., 183., 184.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      131., 132., 133., 134., 145., 146., 147., 148., 157., 158., 159., 160.,
      299., 300., 301., 302., 313., 314., 315., 316., 325., 326., 327., 328.,
      443., 444., 445., 446., 457., 458., 459., 460., 469., 470., 471., 472.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 159., 160., 173., 174.,
                                         175., 176., 349., 350., 351., 352.,
                                         365., 366., 367., 368.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {38., 41.,  45.,  47.5, 87.,  90.,
                                         94., 96.5, 129., 132., 136., 138.5};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46., 50., 102., 106.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75.,  76.,  81.,  82.,  89.,  90.,  94.,  95.,  173., 174., 179., 180.,
      187., 188., 192., 193., 257., 258., 263., 264., 271., 272., 276., 277.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  92.,  99.,  100.,
                                         203., 204., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149., 150., 151., 152., 161., 162., 163., 164., 177., 178., 179., 180.,
      187., 188., 189., 190., 345., 346., 347., 348., 357., 358., 359., 360.,
      373., 374., 375., 376., 383., 384., 385., 386., 513., 514., 515., 516.,
      525., 526., 527., 528., 541., 542., 543., 544., 551., 552., 553., 554.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 183., 184., 197., 198.,
                                         199., 200., 405., 406., 407., 408.,
                                         421., 422., 423., 424.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25.,  28.,  31.,  58.,   61.,   64.,
                                         102., 105., 108., 129.5, 132.5, 135.5};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 41., 81., 85.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  55.,  56.,  61.,  62.,  115., 116., 121., 122., 127., 128.,
      203., 204., 209., 210., 215., 216., 258., 259., 264., 265., 270., 271.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  81.,  82.,
                                         161., 162., 169., 170.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  99.,  100., 109., 110., 111., 112., 121., 122., 123., 124.,
      229., 230., 231., 232., 241., 242., 243., 244., 253., 254., 255., 256.,
      405., 406., 407., 408., 417., 418., 419., 420., 429., 430., 431., 432.,
      515., 516., 517., 518., 527., 528., 529., 530., 539., 540., 541., 542.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 147., 148., 161., 162.,
                                         163., 164., 321., 322., 323., 324.,
                                         337., 338., 339., 340.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27.5,  31.,  34.,  63.5,  67.,  70.,
                                         111.5, 115., 118., 141.5, 145., 148.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40., 44., 88., 92.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54.,  55.,  61.,  62.,  67.,  68.,  126., 127., 133., 134., 139., 140.,
      222., 223., 229., 230., 235., 236., 282., 283., 289., 290., 295., 296.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  80.,  87.,  88.,
                                         175., 176., 183., 184.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107., 108., 109., 110., 121., 122., 123., 124., 133., 134., 135., 136.,
      251., 252., 253., 254., 265., 266., 267., 268., 277., 278., 279., 280.,
      443., 444., 445., 446., 457., 458., 459., 460., 469., 470., 471., 472.,
      563., 564., 565., 566., 577., 578., 579., 580., 589., 590., 591., 592.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 159., 160., 173., 174.,
                                         175., 176., 349., 350., 351., 352.,
                                         365., 366., 367., 368.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31.,  34.,  38.,  40.5, 73.,  76.,
                                         80.,  82.5, 129., 132., 136., 138.5,
                                         164., 167., 171., 173.5};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46., 50., 102., 106.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  67.,  68.,  75.,  76.,  80.,  81.,  145., 146., 151.,
      152., 159., 160., 164., 165., 257., 258., 263., 264., 271., 272.,
      276., 277., 327., 328., 333., 334., 341., 342., 346., 347.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  92.,  99.,  100.,
                                         203., 204., 211., 212.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME1x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 133., 134., 135., 136., 149., 150., 151.,
      152., 159., 160., 161., 162., 289., 290., 291., 292., 301., 302.,
      303., 304., 317., 318., 319., 320., 327., 328., 329., 330., 513.,
      514., 515., 516., 525., 526., 527., 528., 541., 542., 543., 544.,
      551., 552., 553., 554., 653., 654., 655., 656., 665., 666., 667.,
      668., 681., 682., 683., 684., 691., 692., 693., 694.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID1x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 183., 184., 197., 198.,
                                         199., 200., 405., 406., 407., 408.,
                                         421., 422., 423., 424.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  28.,  31.,  58.,  61.,  64.,  91.,  94.,  97.,
      146., 149., 152., 179., 182., 185., 212., 215., 218.,
      267., 270., 273., 300., 303., 306., 333., 336., 339.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  41.,  81.,  85.,  158., 162.,
                                         202., 206., 279., 283., 323., 327.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  55.,  56.,  61.,  62.,  115., 116., 121., 122., 127.,
      128., 181., 182., 187., 188., 193., 194., 291., 292., 297., 298.,
      303., 304., 357., 358., 363., 364., 369., 370., 423., 424., 429.,
      430., 435., 436., 533., 534., 539., 540., 545., 546., 599., 600.,
      605., 606., 611., 612., 665., 666., 671., 672., 677., 678.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  81.,  82.,  161., 162., 169., 170., 315., 316., 323., 324.,
      403., 404., 411., 412., 557., 558., 565., 566., 645., 646., 653., 654.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,   98.,   99.,   100.,  109.,  110.,  111.,  112.,  121.,  122.,
      123.,  124.,  229.,  230.,  231.,  232.,  241.,  242.,  243.,  244.,
      253.,  254.,  255.,  256.,  361.,  362.,  363.,  364.,  373.,  374.,
      375.,  376.,  385.,  386.,  387.,  388.,  581.,  582.,  583.,  584.,
      593.,  594.,  595.,  596.,  605.,  606.,  607.,  608.,  713.,  714.,
      715.,  716.,  725.,  726.,  727.,  728.,  737.,  738.,  739.,  740.,
      845.,  846.,  847.,  848.,  857.,  858.,  859.,  860.,  869.,  870.,
      871.,  872.,  1065., 1066., 1067., 1068., 1077., 1078., 1079., 1080.,
      1089., 1090., 1091., 1092., 1197., 1198., 1199., 1200., 1209., 1210.,
      1211., 1212., 1221., 1222., 1223., 1224., 1329., 1330., 1331., 1332.,
      1341., 1342., 1343., 1344., 1353., 1354., 1355., 1356.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  146.,  147.,  148.,  161.,  162.,  163.,  164.,  321.,  322.,
      323.,  324.,  337.,  338.,  339.,  340.,  629.,  630.,  631.,  632.,
      645.,  646.,  647.,  648.,  805.,  806.,  807.,  808.,  821.,  822.,
      823.,  824.,  1113., 1114., 1115., 1116., 1129., 1130., 1131., 1132.,
      1289., 1290., 1291., 1292., 1305., 1306., 1307., 1308.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27.5,  31.,  34.,  63.5,  67.,  70.,  99.5,  103., 106.,
      159.5, 163., 166., 195.5, 199., 202., 231.5, 235., 238.,
      291.5, 295., 298., 327.5, 331., 334., 363.5, 367., 370.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40.,  44.,  88.,  92.,  172., 176.,
                                         220., 224., 304., 308., 352., 356.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54.,  55.,  61.,  62.,  67.,  68.,  126., 127., 133., 134., 139.,
      140., 198., 199., 205., 206., 211., 212., 318., 319., 325., 326.,
      331., 332., 390., 391., 397., 398., 403., 404., 462., 463., 469.,
      470., 475., 476., 582., 583., 589., 590., 595., 596., 654., 655.,
      661., 662., 667., 668., 726., 727., 733., 734., 739., 740.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79.,  80.,  87.,  88.,  175., 176., 183., 184., 343., 344., 351., 352.,
      439., 440., 447., 448., 607., 608., 615., 616., 703., 704., 711., 712.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107.,  108.,  109.,  110.,  121.,  122.,  123.,  124.,  133.,  134.,
      135.,  136.,  251.,  252.,  253.,  254.,  265.,  266.,  267.,  268.,
      277.,  278.,  279.,  280.,  395.,  396.,  397.,  398.,  409.,  410.,
      411.,  412.,  421.,  422.,  423.,  424.,  635.,  636.,  637.,  638.,
      649.,  650.,  651.,  652.,  661.,  662.,  663.,  664.,  779.,  780.,
      781.,  782.,  793.,  794.,  795.,  796.,  805.,  806.,  807.,  808.,
      923.,  924.,  925.,  926.,  937.,  938.,  939.,  940.,  949.,  950.,
      951.,  952.,  1163., 1164., 1165., 1166., 1177., 1178., 1179., 1180.,
      1189., 1190., 1191., 1192., 1307., 1308., 1309., 1310., 1321., 1322.,
      1323., 1324., 1333., 1334., 1335., 1336., 1451., 1452., 1453., 1454.,
      1465., 1466., 1467., 1468., 1477., 1478., 1479., 1480.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157.,  158.,  159.,  160.,  173.,  174.,  175.,  176.,  349.,  350.,
      351.,  352.,  365.,  366.,  367.,  368.,  685.,  686.,  687.,  688.,
      701.,  702.,  703.,  704.,  877.,  878.,  879.,  880.,  893.,  894.,
      895.,  896.,  1213., 1214., 1215., 1216., 1229., 1230., 1231., 1232.,
      1405., 1406., 1407., 1408., 1421., 1422., 1423., 1424.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,   34.,   38.,   40.5, 73.,   76.,   80.,   82.5, 115.,
      118.,  122.,  124.5, 185., 188.,  192.,  194.5, 227., 230.,
      234.,  236.5, 269.,  272., 276.,  278.5, 339.,  342., 346.,
      348.5, 381.,  384.,  388., 390.5, 423.,  426.,  430., 432.5};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46.,  50.,  102., 106., 200., 204.,
                                         256., 260., 354., 358., 410., 414.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  67.,  68.,  75.,  76.,  80.,  81.,  145., 146., 151., 152.,
      159., 160., 164., 165., 229., 230., 235., 236., 243., 244., 248., 249.,
      369., 370., 375., 376., 383., 384., 388., 389., 453., 454., 459., 460.,
      467., 468., 472., 473., 537., 538., 543., 544., 551., 552., 556., 557.,
      677., 678., 683., 684., 691., 692., 696., 697., 761., 762., 767., 768.,
      775., 776., 780., 781., 845., 846., 851., 852., 859., 860., 864., 865.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91.,  92.,  99.,  100., 203., 204., 211., 212., 399., 400., 407., 408.,
      511., 512., 519., 520., 707., 708., 715., 716., 819., 820., 827., 828.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121.,  122.,  123.,  124.,  133.,  134.,  135.,  136.,  149.,  150.,
      151.,  152.,  159.,  160.,  161.,  162.,  289.,  290.,  291.,  292.,
      301.,  302.,  303.,  304.,  317.,  318.,  319.,  320.,  327.,  328.,
      329.,  330.,  457.,  458.,  459.,  460.,  469.,  470.,  471.,  472.,
      485.,  486.,  487.,  488.,  495.,  496.,  497.,  498.,  737.,  738.,
      739.,  740.,  749.,  750.,  751.,  752.,  765.,  766.,  767.,  768.,
      775.,  776.,  777.,  778.,  905.,  906.,  907.,  908.,  917.,  918.,
      919.,  920.,  933.,  934.,  935.,  936.,  943.,  944.,  945.,  946.,
      1073., 1074., 1075., 1076., 1085., 1086., 1087., 1088., 1101., 1102.,
      1103., 1104., 1111., 1112., 1113., 1114., 1353., 1354., 1355., 1356.,
      1365., 1366., 1367., 1368., 1381., 1382., 1383., 1384., 1391., 1392.,
      1393., 1394., 1521., 1522., 1523., 1524., 1533., 1534., 1535., 1536.,
      1549., 1550., 1551., 1552., 1559., 1560., 1561., 1562., 1689., 1690.,
      1691., 1692., 1701., 1702., 1703., 1704., 1717., 1718., 1719., 1720.,
      1727., 1728., 1729., 1730.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181.,  182.,  183.,  184.,  197.,  198.,  199.,  200.,  405.,  406.,
      407.,  408.,  421.,  422.,  423.,  424.,  797.,  798.,  799.,  800.,
      813.,  814.,  815.,  816.,  1021., 1022., 1023., 1024., 1037., 1038.,
      1039., 1040., 1413., 1414., 1415., 1416., 1429., 1430., 1431., 1432.,
      1637., 1638., 1639., 1640., 1653., 1654., 1655., 1656.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.5,  33.5,  36.5,  69.,  72.,  75.,  102., 105., 108.,
      162.5, 165.5, 168.5, 201., 204., 207., 234., 237., 240.,
      294.5, 297.5, 300.5, 333., 336., 339., 366., 369., 372.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  41.,  81.,  85.,  169., 173.,
                                         213., 217., 301., 305., 345., 349.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60.,  61.,  66.,  67.,  72.,  73.,  137., 138., 143., 144., 149.,
      150., 203., 204., 209., 210., 215., 216., 324., 325., 330., 331.,
      336., 337., 401., 402., 407., 408., 413., 414., 467., 468., 473.,
      474., 479., 480., 588., 589., 594., 595., 600., 601., 665., 666.,
      671., 672., 677., 678., 731., 732., 737., 738., 743., 744.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  81.,  82.,  161., 162., 169., 170., 337., 338., 345., 346.,
      425., 426., 433., 434., 601., 602., 609., 610., 689., 690., 697., 698.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119.,  120.,  121.,  122.,  131.,  132.,  133.,  134.,  143.,  144.,
      145.,  146.,  273.,  274.,  275.,  276.,  285.,  286.,  287.,  288.,
      297.,  298.,  299.,  300.,  405.,  406.,  407.,  408.,  417.,  418.,
      419.,  420.,  429.,  430.,  431.,  432.,  647.,  648.,  649.,  650.,
      659.,  660.,  661.,  662.,  671.,  672.,  673.,  674.,  801.,  802.,
      803.,  804.,  813.,  814.,  815.,  816.,  825.,  826.,  827.,  828.,
      933.,  934.,  935.,  936.,  945.,  946.,  947.,  948.,  957.,  958.,
      959.,  960.,  1175., 1176., 1177., 1178., 1187., 1188., 1189., 1190.,
      1199., 1200., 1201., 1202., 1329., 1330., 1331., 1332., 1341., 1342.,
      1343., 1344., 1353., 1354., 1355., 1356., 1461., 1462., 1463., 1464.,
      1473., 1474., 1475., 1476., 1485., 1486., 1487., 1488.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  146.,  147.,  148.,  161.,  162.,  163.,  164.,  321.,  322.,
      323.,  324.,  337.,  338.,  339.,  340.,  673.,  674.,  675.,  676.,
      689.,  690.,  691.,  692.,  849.,  850.,  851.,  852.,  865.,  866.,
      867.,  868.,  1201., 1202., 1203., 1204., 1217., 1218., 1219., 1220.,
      1377., 1378., 1379., 1380., 1393., 1394., 1395., 1396.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.5,  37.,  40.,  75.5,  79.,  82.,  111.5, 115., 118.,
      177.5, 181., 184., 219.5, 223., 226., 255.5, 259., 262.,
      321.5, 325., 328., 363.5, 367., 370., 399.5, 403., 406.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40.,  44.,  88.,  92.,  184., 188.,
                                         232., 236., 328., 332., 376., 380.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      66.,  67.,  73.,  74.,  79.,  80.,  150., 151., 157., 158., 163.,
      164., 222., 223., 229., 230., 235., 236., 354., 355., 361., 362.,
      367., 368., 438., 439., 445., 446., 451., 452., 510., 511., 517.,
      518., 523., 524., 642., 643., 649., 650., 655., 656., 726., 727.,
      733., 734., 739., 740., 798., 799., 805., 806., 811., 812.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79.,  80.,  87.,  88.,  175., 176., 183., 184., 367., 368., 375., 376.,
      463., 464., 471., 472., 655., 656., 663., 664., 751., 752., 759., 760.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      131.,  132.,  133.,  134.,  145.,  146.,  147.,  148.,  157.,  158.,
      159.,  160.,  299.,  300.,  301.,  302.,  313.,  314.,  315.,  316.,
      325.,  326.,  327.,  328.,  443.,  444.,  445.,  446.,  457.,  458.,
      459.,  460.,  469.,  470.,  471.,  472.,  707.,  708.,  709.,  710.,
      721.,  722.,  723.,  724.,  733.,  734.,  735.,  736.,  875.,  876.,
      877.,  878.,  889.,  890.,  891.,  892.,  901.,  902.,  903.,  904.,
      1019., 1020., 1021., 1022., 1033., 1034., 1035., 1036., 1045., 1046.,
      1047., 1048., 1283., 1284., 1285., 1286., 1297., 1298., 1299., 1300.,
      1309., 1310., 1311., 1312., 1451., 1452., 1453., 1454., 1465., 1466.,
      1467., 1468., 1477., 1478., 1479., 1480., 1595., 1596., 1597., 1598.,
      1609., 1610., 1611., 1612., 1621., 1622., 1623., 1624.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157.,  158.,  159.,  160.,  173.,  174.,  175.,  176.,  349.,  350.,
      351.,  352.,  365.,  366.,  367.,  368.,  733.,  734.,  735.,  736.,
      749.,  750.,  751.,  752.,  925.,  926.,  927.,  928.,  941.,  942.,
      943.,  944.,  1309., 1310., 1311., 1312., 1325., 1326., 1327., 1328.,
      1501., 1502., 1503., 1504., 1517., 1518., 1519., 1520.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38.,   41.,   45.,   47.5, 87.,   90.,   94.,   96.5, 129.,
      132.,  136.,  138.5, 206., 209.,  213.,  215.5, 255., 258.,
      262.,  264.5, 297.,  300., 304.,  306.5, 374.,  377., 381.,
      383.5, 423.,  426.,  430., 432.5, 465.,  468.,  472., 474.5};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46.,  50.,  102., 106., 214., 218.,
                                         270., 274., 382., 386., 438., 442.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75.,  76.,  81.,  82.,  89.,  90.,  94.,  95.,  173., 174., 179., 180.,
      187., 188., 192., 193., 257., 258., 263., 264., 271., 272., 276., 277.,
      411., 412., 417., 418., 425., 426., 430., 431., 509., 510., 515., 516.,
      523., 524., 528., 529., 593., 594., 599., 600., 607., 608., 612., 613.,
      747., 748., 753., 754., 761., 762., 766., 767., 845., 846., 851., 852.,
      859., 860., 864., 865., 929., 930., 935., 936., 943., 944., 948., 949.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91.,  92.,  99.,  100., 203., 204., 211., 212., 427., 428., 435., 436.,
      539., 540., 547., 548., 763., 764., 771., 772., 875., 876., 883., 884.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149.,  150.,  151.,  152.,  161.,  162.,  163.,  164.,  177.,  178.,
      179.,  180.,  187.,  188.,  189.,  190.,  345.,  346.,  347.,  348.,
      357.,  358.,  359.,  360.,  373.,  374.,  375.,  376.,  383.,  384.,
      385.,  386.,  513.,  514.,  515.,  516.,  525.,  526.,  527.,  528.,
      541.,  542.,  543.,  544.,  551.,  552.,  553.,  554.,  821.,  822.,
      823.,  824.,  833.,  834.,  835.,  836.,  849.,  850.,  851.,  852.,
      859.,  860.,  861.,  862.,  1017., 1018., 1019., 1020., 1029., 1030.,
      1031., 1032., 1045., 1046., 1047., 1048., 1055., 1056., 1057., 1058.,
      1185., 1186., 1187., 1188., 1197., 1198., 1199., 1200., 1213., 1214.,
      1215., 1216., 1223., 1224., 1225., 1226., 1493., 1494., 1495., 1496.,
      1505., 1506., 1507., 1508., 1521., 1522., 1523., 1524., 1531., 1532.,
      1533., 1534., 1689., 1690., 1691., 1692., 1701., 1702., 1703., 1704.,
      1717., 1718., 1719., 1720., 1727., 1728., 1729., 1730., 1857., 1858.,
      1859., 1860., 1869., 1870., 1871., 1872., 1885., 1886., 1887., 1888.,
      1895., 1896., 1897., 1898.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181.,  182.,  183.,  184.,  197.,  198.,  199.,  200.,  405.,  406.,
      407.,  408.,  421.,  422.,  423.,  424.,  853.,  854.,  855.,  856.,
      869.,  870.,  871.,  872.,  1077., 1078., 1079., 1080., 1093., 1094.,
      1095., 1096., 1525., 1526., 1527., 1528., 1541., 1542., 1543., 1544.,
      1749., 1750., 1751., 1752., 1765., 1766., 1767., 1768.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,   28.,   31.,   58.,   61.,   64.,   102.,  105.,  108.,
      129.5, 132.5, 135.5, 179.,  182.,  185.,  212.,  215.,  218.,
      256.,  259.,  262.,  283.5, 286.5, 289.5, 333.,  336.,  339.,
      366.,  369.,  372.,  410.,  413.,  416.,  437.5, 440.5, 443.5};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  41.,  81.,  85.,  191., 195.,
                                         235., 239., 345., 349., 389., 393.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  55.,  56.,  61.,  62.,  115., 116., 121., 122., 127., 128.,
      203., 204., 209., 210., 215., 216., 258., 259., 264., 265., 270., 271.,
      357., 358., 363., 364., 369., 370., 423., 424., 429., 430., 435., 436.,
      511., 512., 517., 518., 523., 524., 566., 567., 572., 573., 578., 579.,
      665., 666., 671., 672., 677., 678., 731., 732., 737., 738., 743., 744.,
      819., 820., 825., 826., 831., 832., 874., 875., 880., 881., 886., 887.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  81.,  82.,  161., 162., 169., 170., 381., 382., 389., 390.,
      469., 470., 477., 478., 689., 690., 697., 698., 777., 778., 785., 786.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,   98.,   99.,   100.,  109.,  110.,  111.,  112.,  121.,  122.,
      123.,  124.,  229.,  230.,  231.,  232.,  241.,  242.,  243.,  244.,
      253.,  254.,  255.,  256.,  405.,  406.,  407.,  408.,  417.,  418.,
      419.,  420.,  429.,  430.,  431.,  432.,  515.,  516.,  517.,  518.,
      527.,  528.,  529.,  530.,  539.,  540.,  541.,  542.,  713.,  714.,
      715.,  716.,  725.,  726.,  727.,  728.,  737.,  738.,  739.,  740.,
      845.,  846.,  847.,  848.,  857.,  858.,  859.,  860.,  869.,  870.,
      871.,  872.,  1021., 1022., 1023., 1024., 1033., 1034., 1035., 1036.,
      1045., 1046., 1047., 1048., 1131., 1132., 1133., 1134., 1143., 1144.,
      1145., 1146., 1155., 1156., 1157., 1158., 1329., 1330., 1331., 1332.,
      1341., 1342., 1343., 1344., 1353., 1354., 1355., 1356., 1461., 1462.,
      1463., 1464., 1473., 1474., 1475., 1476., 1485., 1486., 1487., 1488.,
      1637., 1638., 1639., 1640., 1649., 1650., 1651., 1652., 1661., 1662.,
      1663., 1664., 1747., 1748., 1749., 1750., 1759., 1760., 1761., 1762.,
      1771., 1772., 1773., 1774.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  146.,  147.,  148.,  161.,  162.,  163.,  164.,  321.,  322.,
      323.,  324.,  337.,  338.,  339.,  340.,  761.,  762.,  763.,  764.,
      777.,  778.,  779.,  780.,  937.,  938.,  939.,  940.,  953.,  954.,
      955.,  956.,  1377., 1378., 1379., 1380., 1393., 1394., 1395., 1396.,
      1553., 1554., 1555., 1556., 1569., 1570., 1571., 1572.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27.5,  31.,  34.,  63.5,  67.,  70.,  111.5, 115., 118.,
      141.5, 145., 148., 195.5, 199., 202., 231.5, 235., 238.,
      279.5, 283., 286., 309.5, 313., 316., 363.5, 367., 370.,
      399.5, 403., 406., 447.5, 451., 454., 477.5, 481., 484.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {40.,  44.,  88.,  92.,  208., 212.,
                                         256., 260., 376., 380., 424., 428.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54.,  55.,  61.,  62.,  67.,  68.,  126., 127., 133., 134., 139., 140.,
      222., 223., 229., 230., 235., 236., 282., 283., 289., 290., 295., 296.,
      390., 391., 397., 398., 403., 404., 462., 463., 469., 470., 475., 476.,
      558., 559., 565., 566., 571., 572., 618., 619., 625., 626., 631., 632.,
      726., 727., 733., 734., 739., 740., 798., 799., 805., 806., 811., 812.,
      894., 895., 901., 902., 907., 908., 954., 955., 961., 962., 967., 968.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79.,  80.,  87.,  88.,  175., 176., 183., 184., 415., 416., 423., 424.,
      511., 512., 519., 520., 751., 752., 759., 760., 847., 848., 855., 856.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107.,  108.,  109.,  110.,  121.,  122.,  123.,  124.,  133.,  134.,
      135.,  136.,  251.,  252.,  253.,  254.,  265.,  266.,  267.,  268.,
      277.,  278.,  279.,  280.,  443.,  444.,  445.,  446.,  457.,  458.,
      459.,  460.,  469.,  470.,  471.,  472.,  563.,  564.,  565.,  566.,
      577.,  578.,  579.,  580.,  589.,  590.,  591.,  592.,  779.,  780.,
      781.,  782.,  793.,  794.,  795.,  796.,  805.,  806.,  807.,  808.,
      923.,  924.,  925.,  926.,  937.,  938.,  939.,  940.,  949.,  950.,
      951.,  952.,  1115., 1116., 1117., 1118., 1129., 1130., 1131., 1132.,
      1141., 1142., 1143., 1144., 1235., 1236., 1237., 1238., 1249., 1250.,
      1251., 1252., 1261., 1262., 1263., 1264., 1451., 1452., 1453., 1454.,
      1465., 1466., 1467., 1468., 1477., 1478., 1479., 1480., 1595., 1596.,
      1597., 1598., 1609., 1610., 1611., 1612., 1621., 1622., 1623., 1624.,
      1787., 1788., 1789., 1790., 1801., 1802., 1803., 1804., 1813., 1814.,
      1815., 1816., 1907., 1908., 1909., 1910., 1921., 1922., 1923., 1924.,
      1933., 1934., 1935., 1936.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157.,  158.,  159.,  160.,  173.,  174.,  175.,  176.,  349.,  350.,
      351.,  352.,  365.,  366.,  367.,  368.,  829.,  830.,  831.,  832.,
      845.,  846.,  847.,  848.,  1021., 1022., 1023., 1024., 1037., 1038.,
      1039., 1040., 1501., 1502., 1503., 1504., 1517., 1518., 1519., 1520.,
      1693., 1694., 1695., 1696., 1709., 1710., 1711., 1712.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  34.,   38.,  40.5,  73.,  76.,   80.,  82.5,  129., 132.,
      136., 138.5, 164., 167.,  171., 173.5, 227., 230.,  234., 236.5,
      269., 272.,  276., 278.5, 325., 328.,  332., 334.5, 360., 363.,
      367., 369.5, 423., 426.,  430., 432.5, 465., 468.,  472., 474.5,
      521., 524.,  528., 530.5, 556., 559.,  563., 565.5};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46.,  50.,  102., 106., 242., 246.,
                                         298., 302., 438., 442., 494., 498.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,   62.,   67.,   68.,   75.,   76.,   80.,   81.,   145.,  146.,
      151.,  152.,  159.,  160.,  164.,  165.,  257.,  258.,  263.,  264.,
      271.,  272.,  276.,  277.,  327.,  328.,  333.,  334.,  341.,  342.,
      346.,  347.,  453.,  454.,  459.,  460.,  467.,  468.,  472.,  473.,
      537.,  538.,  543.,  544.,  551.,  552.,  556.,  557.,  649.,  650.,
      655.,  656.,  663.,  664.,  668.,  669.,  719.,  720.,  725.,  726.,
      733.,  734.,  738.,  739.,  845.,  846.,  851.,  852.,  859.,  860.,
      864.,  865.,  929.,  930.,  935.,  936.,  943.,  944.,  948.,  949.,
      1041., 1042., 1047., 1048., 1055., 1056., 1060., 1061., 1111., 1112.,
      1117., 1118., 1125., 1126., 1130., 1131.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91.,  92.,  99.,  100., 203., 204., 211., 212., 483., 484., 491., 492.,
      595., 596., 603., 604., 875., 876., 883., 884., 987., 988., 995., 996.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, SAME3x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {121.,
                                         122.,
                                         123.,
                                         124.,
                                         133.,
                                         134.,
                                         135.,
                                         136.,
                                         149.,
                                         150.,
                                         151.,
                                         152.,
                                         159.,
                                         160.,
                                         161.,
                                         162.,
                                         289.,
                                         290.,
                                         291.,
                                         292.,
                                         301.,
                                         302.,
                                         303.,
                                         304.,
                                         317.,
                                         318.,
                                         319.,
                                         320.,
                                         327.,
                                         328.,
                                         329.,
                                         330.,
                                         513.,
                                         514.,
                                         515.,
                                         516.,
                                         525.,
                                         526.,
                                         527.,
                                         528.,
                                         541.,
                                         542.,
                                         543.,
                                         544.,
                                         551.,
                                         552.,
                                         553.,
                                         554.,
                                         653.,
                                         654.,
                                         655.,
                                         656.,
                                         665.,
                                         666.,
                                         667.,
                                         668.,
                                         681.,
                                         682.,
                                         683.,
                                         684.,
                                         691.,
                                         692.,
                                         693.,
                                         694.,
                                         905.,
                                         906.,
                                         907.,
                                         908.,
                                         917.,
                                         918.,
                                         919.,
                                         920.,
                                         933.,
                                         934.,
                                         935.,
                                         936.,
                                         943.,
                                         944.,
                                         945.,
                                         946.,
                                         1073.,
                                         1074.,
                                         1075.,
                                         1076.,
                                         1085.,
                                         1086.,
                                         1087.,
                                         1088.,
                                         1101.,
                                         1102.,
                                         1103.,
                                         1104.,
                                         1111.,
                                         1112.,
                                         1113.,
                                         1114.,
                                         1297.,
                                         1298.,
                                         1299.,
                                         1300.,
                                         1309.,
                                         1310.,
                                         1311.,
                                         1312.,
                                         1325.,
                                         1326.,
                                         1327.,
                                         1328.,
                                         1335.,
                                         1336.,
                                         1337.,
                                         1338.,
                                         1437.,
                                         1438.,
                                         1439.,
                                         1440.,
                                         1449.,
                                         1450.,
                                         1451.,
                                         1452.,
                                         1465.,
                                         1466.,
                                         1467.,
                                         1468.,
                                         1475.,
                                         1476.,
                                         1477.,
                                         1478.,
                                         1689.,
                                         1690.,
                                         1691.,
                                         1692.,
                                         1701.,
                                         1702.,
                                         1703.,
                                         1704.,
                                         1717.,
                                         1718.,
                                         1719.,
                                         1720.,
                                         1727.,
                                         1728.,
                                         1729.,
                                         1730.,
                                         1857.,
                                         1858.,
                                         1859.,
                                         1860.,
                                         1827.204081632653,
                                         1828.204081632653,
                                         1829.204081632653,
                                         1830.204081632653,
                                         1676.0204081632653,
                                         1677.0204081632653,
                                         1678.0204081632653,
                                         1679.0204081632653,
                                         1602.4285714285713,
                                         1603.4285714285713,
                                         1604.4285714285713,
                                         1605.4285714285713,
                                         910.7142857142857,
                                         911.7142857142857,
                                         912.7142857142857,
                                         913.7142857142857,
                                         880.9183673469388,
                                         881.9183673469388,
                                         882.9183673469388,
                                         883.9183673469388,
                                         729.734693877551,
                                         730.734693877551,
                                         731.734693877551,
                                         732.734693877551,
                                         656.1428571428571,
                                         657.1428571428571,
                                         658.1428571428571,
                                         659.1428571428571,
                                         173.,
                                         174.,
                                         175.,
                                         176.,
                                         185.,
                                         186.,
                                         187.,
                                         188.,
                                         201.,
                                         202.,
                                         203.,
                                         204.,
                                         211.,
                                         212.,
                                         213.,
                                         214.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow7Stride4Forward, VALID3x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181.,
                                         182.,
                                         183.,
                                         184.,
                                         197.,
                                         198.,
                                         199.,
                                         200.,
                                         405.,
                                         406.,
                                         407.,
                                         408.,
                                         421.,
                                         422.,
                                         423.,
                                         424.,
                                         965.,
                                         966.,
                                         967.,
                                         968.,
                                         981.,
                                         982.,
                                         983.,
                                         984.,
                                         1189.,
                                         1190.,
                                         1191.,
                                         1192.,
                                         1205.,
                                         1206.,
                                         1207.,
                                         1208.,
                                         1749.,
                                         1750.,
                                         1751.,
                                         1752.,
                                         1765.,
                                         1766.,
                                         1767.,
                                         1768.,
                                         1387.857142857143,
                                         1388.857142857143,
                                         1389.857142857143,
                                         1390.857142857143,
                                         1278.469387755102,
                                         1279.469387755102,
                                         1280.469387755102,
                                         1281.469387755102};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
